/**
 * markdown-it dataset插件
 * 处理 ```dataset 代码块，将其转换为可编辑的数据集容器
 */

// 导入CSS样式
import './markdownItDataset.css'
import { BaseRenderer } from './BaseRenderer'

// 全局数据源函数（保持不变，因为数据源是外部注入的）
const dataSourceFunctions = {
  getDataSource: window.getDataSource,
  getDataSourceList: window.getDataSourceList,
  clearDataSourceCache: window.clearDataSourceCache,
  testDataSourceConnection: window.testDataSourceConnection
}

export class DatasetRenderer extends BaseRenderer {
  constructor() {
    super()
    // 实例级别的数据集存储，避免多个实例之间的冲突
    this.datasets = new Map()
    this.dataset = {}
    this.dataSourceFunctions = null
  }

  /**
   * HTML转义方法，防止XSS攻击
   */
  escapeHtml(text) {
    const map = {
      '&': '&amp;',
      '<': '&lt;',
      '>': '&gt;',
      '"': '&quot;',
      "'": '&#x27;',
      '/': '&#x2F;'
    };
    return String(text).replace(/[&<>"'\/]/g, (char) => map[char]);
  }

  // 获取实例级别的数据集存储
  getDatasets() {
    return this.datasets;
  }

  // 获取实例级别的dataset对象
  getDataset() {
    return this.dataset;
  }

  // 设置数据源函数（从外部注入）
  setDataSourceFunctions(functions) {
    this.dataSourceFunctions = functions;
  }

  /**
   * 渲染所有数据集容器
   */
  async renderDatasets() {
    const containers = document.querySelectorAll('.dataset-container');
    
    // 如果没有数据集容器，直接触发完成事件
    if (containers.length === 0) {
      this.triggerRenderComplete();
      return;
    }
    
    // 使用 Promise.all 确保所有异步操作完成
    const renderPromises = Array.from(containers).map(async (container, index) => {
      if (container.dataset.rendered) {
        return;
      }
      
      // 在 try 块外部保存原始代码，用于错误报告
      // 优先使用 data-original-code 属性（包含完整的 markdown 代码块）
      const originalCode = container.dataset.originalCode || container.textContent || container.dataset.dataset || '';
      const datasetId = container.dataset.datasetId || `dataset-${index}`;
      
      try {
        const datasetContent = container.dataset.dataset || '';
        const isDataSourceQuery = container.dataset.isDatasource === 'true' || container.dataset.isDatasource === true;
        
        // 检查内容是否为空
        if (!datasetContent.trim()) {
          throw new Error('数据集内容为空');
        }
        
        let dataset;
        
        if (isDataSourceQuery) {
          // 处理数据源查询格式
          dataset = await this.parseDataSourceQuery(datasetContent);
        } else {
          // 使用Function构造函数将JavaScript对象字符串转换为对象
          try {
            // 直接解析，不使用 decodeURIComponent
            // 因为：1) HTML 属性已经自动解码 HTML 实体
            //      2) 中文字符不需要 URL 解码
            //      3) % 字符会导致 decodeURIComponent 失败
            const getDataset = new Function(`return (${datasetContent})`);
            dataset = getDataset();
          } catch (e) {
            // 如果JavaScript解析失败，尝试直接解析（可能已经是对象）
            try {
              dataset = JSON.parse(datasetContent);
            } catch (jsonError) {
              // 如果直接解析也失败，尝试其他格式
              throw new Error('无法解析数据集配置');
            }
          }
        }
        
        this.renderDataset(container, dataset, datasetId);
        container.dataset.rendered = 'true';
      } catch (error) {
        console.error('Error rendering dataset:', error);
        console.error('Dataset ID:', datasetId);
        console.error('Dataset content that caused error:', originalCode);
        container.innerHTML = `<div class="dataset-error">数据集渲染错误: ${error.message}</div>`;
        
        // 收集错误信息 - 使用原始代码而不是编码后的内容
        this.addError({
          type: 'Dataset',
          message: error.message,
          code: originalCode,
          datasetId: datasetId,
          timestamp: Date.now()
        });
      }
    });
    
    // 等待所有数据集渲染完成
    await Promise.all(renderPromises);
    
    // 所有数据集渲染完成后触发事件
    this.triggerRenderComplete();
  }

  /**
   * 解析数据源查询格式
   */
  async parseDataSourceQuery(queryContent) {
    try {
      // 解析新的格式: datasetId: sql_query_1 datasourceId: demo_db + SQL语句
      let sourceId, sql;
      
      // 检查是否为新的格式: 第一行包含datasetId:和datasourceId:
      const lines = queryContent.split('\n').map(line => line.trim()).filter(line => line);
      
      if (lines.length >= 1) {
        const firstLine = lines[0];
        
        // 检查第一行是否包含datasourceId:
        if (firstLine.includes('datasourceId:')) {
          // 提取数据源ID - 支持新的格式: datasetId: sql_query_1 datasourceId: demo_db
          const datasourceMatch = firstLine.match(/datasourceId:\s*(\S+)/);
          if (datasourceMatch && datasourceMatch[1]) {
            sourceId = datasourceMatch[1];
            
            // 从第二行开始查找SQL语句
            const sqlLines = [];
            for (let i = 1; i < lines.length; i++) {
              const line = lines[i];
              sqlLines.push(line);
            }
            
            sql = sqlLines.join(' ').trim();
            
            if (!sql) {
              throw new Error('SQL查询语句不能为空');
            }
          } else {
            throw new Error('数据源ID格式不正确，应为: datasourceId:数据源ID');
          }
        } else {
          // 如果第一行不包含datasourceId:，检查是否包含datasetId:（这是SQL查询格式）
          if (firstLine.includes('datasetId:')) {
            // 从第二行开始查找SQL语句
            const sqlLines = [];
            for (let i = 1; i < lines.length; i++) {
              const line = lines[i];
              sqlLines.push(line);
            }
            
            sql = sqlLines.join(' ').trim();
            
            if (!sql) {
              throw new Error('SQL查询语句不能为空');
            }
            
            // 对于SQL查询格式，使用默认数据源
            sourceId = 'sales_db';
          } else {
            throw new Error('数据源查询格式不正确，第一行必须包含datasetId:或datasourceId:');
          }
        }
      } else {
        throw new Error('数据源查询内容不能为空');
      }
      
      if (!sourceId) {
        throw new Error('数据源ID未指定');
      }
      
      // 检查实例级别的数据源函数是否存在
      if (!this.dataSourceFunctions || typeof this.dataSourceFunctions.getDataSource !== 'function') {
        throw new Error('数据源获取函数未注入，请确保已设置datasource属性');
      }
      
      // 调用实例级别的数据源函数获取数据
      const result = await this.dataSourceFunctions.getDataSource(sourceId, sql, {});
      
      // 返回标准dataset格式，保留metadata信息
      return {
        dimensions: result.dimensions || Object.keys(result.source[0] || {}),
        source: result.source,
        metadata: result.metadata
      };
      
    } catch (error) {
      console.error('数据源查询解析失败:', error);
      throw new Error(`数据源查询失败: ${error.message}`);
    }
  }

  /**
   * 触发渲染完成事件
   */
  triggerRenderComplete() {
    const event = new CustomEvent('datasetsRendered', {
      detail: { timestamp: Date.now() }
    });
    document.dispatchEvent(event);
  }

  /**
   * 渲染单个数据集
   */
  renderDataset(container, dataset, datasetId) {
    // 验证数据集格式
    if (!this.validateDataset(dataset)) {
      console.error('Dataset validation failed for dataset:', dataset);
      console.error('Dataset ID:', datasetId);
      container.innerHTML = '<div class="dataset-error">数据集格式错误</div>';
      return;
    }

    // 创建数据集界面
    const html = this.createDatasetHTML(dataset, datasetId);
    container.innerHTML = html;
    
    // 存储数据集供后续使用
    this.datasets.set(datasetId, dataset);
    
    // 更新实例级别的dataset对象
    this.dataset[datasetId] = dataset;
    
    // 绑定折叠/展开事件
    this.bindToggleEvent(container, datasetId);
    
    // 绑定筛选器事件
    this.bindFilterEvents(container, datasetId);
  }

  /**
   * 验证数据集格式 - 现在直接返回true，不进行验证
   */
  validateDataset(dataset) {
    // 直接返回true，不进行任何验证
    return true;
  }

  /**
   * 创建数据集HTML界面
   */
  createDatasetHTML(dataset, datasetId) {
    const fields = this.getDatasetFields(dataset);
    const dataCount = this.getDataCount(dataset);
    const isDataSource = dataset.metadata && dataset.metadata.sourceId;
    
    return `
      <div class="dataset-panel">
        <div class="dataset-header" data-dataset-id="${datasetId}">
          <div class="dataset-header-content">
            <svg class="dataset-icon" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
              <path d="M324.576 786.272l0-109.728q0-8-5.152-13.152t-13.152-5.152l-182.848 0q-8 0-13.152 5.152t-5.152 13.152l0 109.728q0 8 5.152 13.152t13.152 5.152l182.848 0q8 0 13.152-5.152t5.152-13.152zM324.576 566.848l0-109.728q0-8-5.152-13.152t-13.152-5.152l-182.848 0q-8 0-13.152 5.152t-5.152 13.152l0 109.728q0 8 5.152 13.152t13.152 5.152l182.848 0q8 0 13.152-5.152t5.152-13.152zM617.152 786.272l0-109.728q0-8-5.152-13.152t-13.152-5.152l-182.848 0q-8 0-13.152 5.152t-5.152 13.152l0 109.728q0 8 5.152 13.152t13.152 5.152l182.848 0q8 0 13.152-5.152t5.152-13.152zM324.576 347.424l0-109.728q0-8-5.152-13.152t-13.152-5.152l-182.848 0q-8 0-13.152 5.152t-5.152 13.152l0 109.728q0 8 5.152 13.152t13.152 5.152l182.848 0q8 0 13.152-5.152t5.152-13.152zM617.152 566.848l0-109.728q0-8-5.152-13.152t-13.152-5.152l-182.848 0q-8 0-13.152 5.152t-5.152 13.152l0 109.728q0 8 5.152 13.152t13.152 5.152l182.848 0q8 0 13.152-5.152t5.152-13.152zM909.728 786.272l0-109.728q0-8-5.152-13.152t-13.152-5.152l-182.848 0q-8 0-13.152 5.152t-5.152 13.152l0 109.728q0 8 5.152 13.152t13.152 5.152l182.848 0q8 0 13.152-5.152t5.152-13.152zM617.152 347.424l0-109.728q0-8-5.152-13.152t-13.152-5.152l-182.848 0q-8 0-13.152 5.152t-5.152 13.152l0 109.728q0 8 5.152 13.152t13.152 5.152l182.848 0q8 0 13.152-5.152t5.152-13.152zM909.728 566.848l0-109.728q0-8-5.152-13.152t-13.152-5.152l-182.848 0q-8 0-13.152 5.152t-5.152 13.152l0 109.728q0 8 5.152 13.152t13.152 5.152l182.848 0q8 0 13.152-5.152t5.152-13.152zM909.728 347.424l0-109.728q0-8-5.152-13.152t-13.152-5.152l-182.848 0q-8 0-13.152 5.152t-5.152 13.152l0 109.728q0 8 5.152 13.152t13.152 5.152l182.848 0q8 0 13.152-5.152t5.152-13.152zM982.848 164.576l0 621.728q0 37.728-26.848 64.576t-64.576 26.848l-768 0q-37.728 0-64.576-26.848t-26.848-64.576l0-621.728q0-37.728 26.848-64.576t64.576-26.848l768 0q37.728 0 64.576 26.848t26.848 64.576z" />
            </svg>
            <span class="dataset-id">${datasetId}</span>
            <span class="dataset-info">${dataCount} 条记录</span>
            ${isDataSource ? `<span class="datasource-info">数据源: ${dataset.metadata.sourceId}</span>` : ''}
          </div>
        </div>
        
        <div class="dataset-content" style="display: none;">
          <div class="dataset-filters">
            <div class="filter-section">
              <div class="data-filters">
                <div class="condition-builder">
                  <select class="condition-field">
                    <option value="">选择字段</option>
                    ${fields.map(field => `<option value="${field}">${field}</option>`).join('')}
                  </select>
                  <select class="condition-operator">
                    <option value="contains">包含</option>
                    <option value="equals">等于</option>
                    <option value="not-equals">不等于</option>
                    <option value="starts-with">开头是</option>
                    <option value="ends-with">结尾是</option>
                    <option value="greater-than">大于</option>
                    <option value="greater-than-equals">大于等于</option>
                    <option value="less-than">小于</option>
                    <option value="less-than-equals">小于等于</option>
                  </select>
                  <input type="text" class="condition-value" placeholder="输入值">
                  <button class="condition-add-btn" data-action="add-condition">添加筛选</button>
                  <button class="action-btn" data-action="preview">预览</button>
                  <button class="action-btn" data-action="export">导出</button>
                </div>
                <div class="condition-tags" style="display: none;"></div>
              </div>
            </div>
          </div>
          
          <div class="dataset-preview" style="display: none;">
            <div class="preview-table-container">
              <table class="preview-table">
                <thead>
                  <tr>
                    ${fields.map(field => `<th>${field}</th>`).join('')}
                  </tr>
                </thead>
                <tbody>
                  ${this.getPreviewRows(dataset, fields, 5).join('')}
                </tbody>
              </table>
            </div>
          </div>
        </div>
      </div>
    `;
  }

  /**
   * 获取数据集字段
   */
  getDatasetFields(dataset) {
    if (dataset.dimensions && Array.isArray(dataset.dimensions)) {
      return dataset.dimensions;
    } else if (Array.isArray(dataset.source) && dataset.source.length > 0) {
      const firstRow = dataset.source[0];
      // 确保第一行是数组或对象
      if (Array.isArray(firstRow)) {
        return firstRow; // 第一行作为字段名
      } else if (typeof firstRow === 'object' && firstRow !== null) {
        return Object.keys(firstRow);
      } else {
        console.error('getDatasetFields: dataset.source[0] 格式错误', { firstRow, dataset });
        throw new Error(`数据集第一行格式错误，期望数组或对象，实际类型: ${typeof firstRow}`);
      }
    } else if (Array.isArray(dataset) && dataset.length > 0) {
      // 处理二维数组格式
      const firstRow = dataset[0];
      if (Array.isArray(firstRow)) {
        return firstRow; // 第一行作为字段名
      } else if (typeof firstRow === 'object' && firstRow !== null) {
        return Object.keys(firstRow);
      } else {
        console.error('getDatasetFields: dataset[0] 格式错误', { firstRow, dataset });
        throw new Error(`数据集第一行格式错误，期望数组或对象，实际类型: ${typeof firstRow}`);
      }
    }
    console.error('getDatasetFields: 无法提取字段', { dataset });
    throw new Error('数据集格式错误: 无法提取字段信息，请检查数据集结构');
  }

  /**
   * 获取数据数量
   */
  getDataCount(dataset) {
    if (Array.isArray(dataset.source)) {
      return dataset.source.length - 1; // 减去标题行
    } else if (Array.isArray(dataset)) {
      // 处理二维数组格式
      return dataset.length - 1; // 减去标题行
    }
    return dataset.source ? dataset.source.length : 0;
  }

  /**
   * 获取预览行数据
   */
  getPreviewRows(dataset, fields, limit = 5) {
    const rows = [];
    
    // 验证 fields 是否为数组
    if (!Array.isArray(fields)) {
      console.error('getPreviewRows: fields 不是数组', { fields, dataset });
      throw new Error(`字段列表必须是数组，当前类型: ${typeof fields}`);
    }
    
    if (dataset.dimensions && Array.isArray(dataset.source)) {
      // 格式2: 对象数组
      for (let i = 0; i < Math.min(limit, dataset.source.length); i++) {
        const item = dataset.source[i];
        const cells = fields.map(field => `<td>${item[field] || ''}</td>`).join('');
        rows.push(`<tr>${cells}</tr>`);
      }
    } else if (Array.isArray(dataset.source)) {
      // 格式1: 二维数组（包含source属性）
      for (let i = 1; i < Math.min(limit + 1, dataset.source.length); i++) {
        const row = dataset.source[i];
        if (!Array.isArray(row)) {
          console.error('getPreviewRows: 行数据不是数组', { row, index: i, dataset });
          throw new Error(`第 ${i} 行数据必须是数组，当前类型: ${typeof row}`);
        }
        const cells = row.map(cell => `<td>${cell}</td>`).join('');
        rows.push(`<tr>${cells}</tr>`);
      }
    } else if (Array.isArray(dataset)) {
      // 直接是二维数组格式
      for (let i = 1; i < Math.min(limit + 1, dataset.length); i++) {
        const row = dataset[i];
        if (!Array.isArray(row)) {
          console.error('getPreviewRows: 行数据不是数组', { row, index: i, dataset });
          throw new Error(`第 ${i} 行数据必须是数组，当前类型: ${typeof row}`);
        }
        const cells = row.map(cell => `<td>${cell}</td>`).join('');
        rows.push(`<tr>${cells}</tr>`);
      }
    }
    
    return rows;
  }

  /**
   * 绑定折叠/展开事件
   */
  bindToggleEvent(container, datasetId) {
    const header = container.querySelector('.dataset-header');
    const content = container.querySelector('.dataset-content');
    
    if (header && content) {
      header.style.cursor = 'pointer';
      
      header.addEventListener('click', () => {
        const isExpanded = content.style.display === 'block';
        
        if (isExpanded) {
          // 折叠
          content.style.display = 'none';
          header.classList.remove('expanded');
        } else {
          // 展开
          content.style.display = 'block';
          header.classList.add('expanded');
        }
      });
    }
  }

  /**
   * 绑定筛选器事件
   */
  bindFilterEvents(container, datasetId) {
    // 预览按钮
    container.querySelector('[data-action="preview"]')?.addEventListener('click', () => {
      const preview = container.querySelector('.dataset-preview');
      const isVisible = preview.style.display === 'block';
      
      if (!isVisible) {
        // 显示预览时总是重新加载数据
        this.showPreview(container, datasetId);
      } else {
        // 隐藏预览
        preview.style.display = 'none';
      }
    });

    // 导出按钮
    container.querySelector('[data-action="export"]')?.addEventListener('click', () => {
      this.exportDataset(datasetId);
    });

    // 添加筛选按钮
    container.querySelector('[data-action="add-condition"]')?.addEventListener('click', () => {
      this.addCondition(container, datasetId);
    });

    // 初始化条件存储
    this.conditions = this.conditions || new Map();
    this.conditions.set(datasetId, []);
  }

  /**
   * 显示预览数据
   */
  showPreview(container, datasetId) {
    const preview = container.querySelector('.dataset-preview');
    
    // 获取数据集：优先使用筛选后的数据，如果没有则使用原始数据
    let targetDataset = this.dataset[datasetId];
    
    // 如果筛选后的数据集不存在，则从存储中获取原始数据集
    if (!targetDataset) {
      targetDataset = this.datasets.get(datasetId);
    }
    
    // 确保数据集存在
    if (targetDataset) {
      const fields = this.getDatasetFields(targetDataset);
      const previewRows = this.getPreviewRows(targetDataset, fields, 5); // 修改为显示前5行
      
      const tbody = preview.querySelector('tbody');
      tbody.innerHTML = previewRows.join('');
      
      // 添加分页控件
      this.addPagination(container, datasetId, targetDataset, fields);
    } else {
      const tbody = preview.querySelector('tbody');
      tbody.innerHTML = '<tr><td colspan="100">数据集不存在</td></tr>';
    }
    
    preview.style.display = 'block';
  }

  /**
   * 添加分页控件
   */
  addPagination(container, datasetId, dataset, fields) {
    const preview = container.querySelector('.dataset-preview');
    let pagination = preview.querySelector('.dataset-pagination');
    
    // 如果分页控件已存在，先移除
    if (pagination) {
      pagination.remove();
    }
    
    // 创建分页控件
    pagination = document.createElement('div');
    pagination.className = 'dataset-pagination';
    
    const totalRows = dataset.source.length;
    let pageSize = 5; // 默认每页显示5条记录
    let totalPages = Math.ceil(totalRows / pageSize);
    
    // 如果数据量小于等于一页，不需要分页
    if (totalPages <= 1) {
      return;
    }
    
    // 当前页码状态
    let currentPage = 1;
    
    // 分页控件HTML
    pagination.innerHTML = `
      <div class="pagination-info">
        显示第 <span class="current-range">1-${Math.min(pageSize, totalRows)}</span> 条，共 ${totalRows} 条记录
      </div>
      <div class="pagination-controls">
        <button class="pagination-btn" data-action="prev-page" ${currentPage === 1 ? 'disabled' : ''}>&lt;</button>
        <span class="pagination-status">${currentPage} / ${totalPages}</span>
        <button class="pagination-btn" data-action="next-page" ${currentPage === totalPages ? 'disabled' : ''}>&gt;</button>
      </div>
      <div class="pagination-size">
        <span>每页显示：</span>
        <select class="page-size-select">
          <option value="5" ${pageSize === 5 ? 'selected' : ''}>5</option>
          <option value="10" ${pageSize === 10 ? 'selected' : ''}>10</option>
          <option value="20" ${pageSize === 20 ? 'selected' : ''}>20</option>
          <option value="50" ${pageSize === 50 ? 'selected' : ''}>50</option>
        </select>
        <span>条</span>
      </div>
    `;
    
    // 绑定分页事件
    pagination.querySelector('[data-action="prev-page"]')?.addEventListener('click', () => {
      if (currentPage > 1) {
        currentPage--;
        this.updatePreviewPage(container, datasetId, dataset, fields, currentPage, pageSize, pagination);
      }
    });
    
    pagination.querySelector('[data-action="next-page"]')?.addEventListener('click', () => {
      if (currentPage < totalPages) {
        currentPage++;
        this.updatePreviewPage(container, datasetId, dataset, fields, currentPage, pageSize, pagination);
      }
    });
    
    // 绑定每页显示数量变化事件
    pagination.querySelector('.page-size-select')?.addEventListener('change', (event) => {
      const newPageSize = parseInt(event.target.value);
      pageSize = newPageSize;
      totalPages = Math.ceil(totalRows / pageSize);
      
      // 如果当前页码超出新的总页数，则重置为第一页
      if (currentPage > totalPages) {
        currentPage = 1;
      }
      
      this.updatePreviewPage(container, datasetId, dataset, fields, currentPage, pageSize, pagination);
    });
    
    preview.appendChild(pagination);
  }

  /**
   * 更新预览页面
   */
  updatePreviewPage(container, datasetId, dataset, fields, currentPage, pageSize, pagination) {
    const startIndex = (currentPage - 1) * pageSize;
    const endIndex = Math.min(startIndex + pageSize, dataset.source.length);
    const previewRows = this.getPreviewRows(dataset, fields, pageSize, startIndex);
    
    const tbody = container.querySelector('.dataset-preview tbody');
    tbody.innerHTML = previewRows.join('');
    
    // 更新分页信息
    const totalRows = dataset.source.length;
    const totalPages = Math.ceil(totalRows / pageSize);
    
    pagination.querySelector('.current-range').textContent = `${startIndex + 1}-${endIndex}`;
    pagination.querySelector('.pagination-status').textContent = `${currentPage} / ${totalPages}`;
    
    // 更新按钮状态
    pagination.querySelector('[data-action="prev-page"]').disabled = currentPage === 1;
    pagination.querySelector('[data-action="next-page"]').disabled = currentPage === totalPages;
    
    // 更新每页显示数量的选中状态
    const pageSizeSelect = pagination.querySelector('.page-size-select');
    if (pageSizeSelect) {
      pageSizeSelect.value = pageSize;
    }
  }

  /**
   * 获取预览行数据（支持分页）
   */
  getPreviewRows(dataset, fields, limit = 10, startIndex = 0) {
    const rows = [];
    
    // 验证 fields 是否为数组
    if (!Array.isArray(fields)) {
      console.error('getPreviewRows (分页): fields 不是数组', { fields, dataset });
      throw new Error(`字段列表必须是数组，当前类型: ${typeof fields}`);
    }
    
    if (!dataset.source || !Array.isArray(dataset.source)) {
      console.error('getPreviewRows (分页): dataset.source 不存在或不是数组', { dataset });
      throw new Error('数据集source必须是数组');
    }
    
    const endIndex = Math.min(startIndex + limit, dataset.source.length);
    
    // 注意：这里不再添加表头，因为表头已经在HTML模板中定义
    // 只添加数据行
    
    // 添加数据行
    for (let i = startIndex; i < endIndex; i++) {
      const rowData = dataset.source[i];
      
      if (!rowData) {
        console.warn(`getPreviewRows (分页): 第 ${i} 行数据为空`);
        continue;
      }
      
      const rowCells = fields.map(field => {
        let cellValue = '';
        
        if (Array.isArray(rowData)) {
          // 二维数组格式
          const fieldIndex = fields.indexOf(field);
          cellValue = fieldIndex >= 0 ? rowData[fieldIndex] : '';
        } else {
          // 对象格式
          cellValue = rowData[field] || '';
        }
        
        return `<td>${this.escapeHtml(String(cellValue))}</td>`;
      }).join('');
      
      rows.push(`<tr>${rowCells}</tr>`);
    }
    
    return rows;
  }

  /**
   * 添加筛选条件并应用筛选
   */
  addCondition(container, datasetId) {
    const fieldSelect = container.querySelector('.condition-field');
    const operatorSelect = container.querySelector('.condition-operator');
    const valueInput = container.querySelector('.condition-value');
    
    const field = fieldSelect.value;
    const operator = operatorSelect.value;
    const value = valueInput.value.trim();
    
    if (!field || !value) {
      return; // 字段和值不能为空
    }
    
    // 创建条件对象
    const condition = {
      field,
      operator,
      value,
      id: Date.now() + Math.random() // 生成唯一ID
    };
    
    // 存储条件
    const conditions = this.conditions.get(datasetId) || [];
    conditions.push(condition);
    this.conditions.set(datasetId, conditions);
    
    // 更新tag显示
    this.updateConditionTags(container, datasetId);
    
    // 清空输入框
    valueInput.value = '';
    
    // 立即应用筛选
    this.applyFilters(container, datasetId);
  }

  /**
   * 更新条件标签显示
   */
  updateConditionTags(container, datasetId) {
    const conditions = this.conditions.get(datasetId) || [];
    const tagsContainer = container.querySelector('.condition-tags');
    
    // 清空现有标签
    tagsContainer.innerHTML = '';
    
    // 如果有条件，显示标签；否则隐藏容器
    if (conditions.length > 0) {
      tagsContainer.style.display = 'flex';
      
      // 添加新标签
      conditions.forEach(condition => {
        const tag = document.createElement('div');
        tag.className = 'condition-tag';
        tag.dataset.conditionId = condition.id;
        
        // 获取操作符显示文本
        const operatorText = this.getOperatorText(condition.operator);
        
        tag.innerHTML = `
          <span>${condition.field} ${operatorText} "${condition.value}"</span>
          <button class="condition-tag-remove" data-action="remove-condition" data-condition-id="${condition.id}">×</button>
        `;
        
        tagsContainer.appendChild(tag);
      });
      
      // 绑定删除事件
      tagsContainer.querySelectorAll('[data-action="remove-condition"]').forEach(button => {
        button.addEventListener('click', (e) => {
          e.stopPropagation();
          const conditionId = button.dataset.conditionId;
          this.removeCondition(container, datasetId, conditionId);
        });
      });
    } else {
      // 没有条件时隐藏容器
      tagsContainer.style.display = 'none';
    }
  }

  /**
   * 获取操作符显示文本
   */
  getOperatorText(operator) {
    const operatorMap = {
      'contains': '包含',
      'equals': '等于',
      'not-equals': '不等于',
      'starts-with': '开头是',
      'ends-with': '结尾是',
      'greater-than': '大于',
      'greater-than-equals': '大于等于',
      'less-than': '小于',
      'less-than-equals': '小于等于'
    };
    return operatorMap[operator] || operator;
  }

  /**
   * 删除筛选条件
   */
  removeCondition(container, datasetId, conditionId) {
    const conditions = this.conditions.get(datasetId) || [];
    const filteredConditions = conditions.filter(cond => cond.id != conditionId);
    this.conditions.set(datasetId, filteredConditions);
    
    // 更新tag显示
    this.updateConditionTags(container, datasetId);
    
    // 重新应用筛选
    this.applyFilters(container, datasetId);
  }

  /**
   * 根据条件筛选数据集
   */
  filterDatasetWithConditions(originalDataset, conditions) {
    if (!conditions || conditions.length === 0) {
      return originalDataset; // 没有条件时返回原始数据
    }

    // 克隆原始数据集
    const filteredDataset = JSON.parse(JSON.stringify(originalDataset));
    
    // 优先检查对象数组格式（有dimensions字段）
    if (filteredDataset.dimensions && Array.isArray(filteredDataset.source)) {
      // 处理对象数组格式
      
      // 检查所有条件字段是否都存在于dimensions中
      const allFieldsExist = conditions.every(condition => 
        filteredDataset.dimensions.includes(condition.field)
      );
      
      if (!allFieldsExist) {
        return originalDataset;
      }
      
      const filteredSource = filteredDataset.source.filter((item, index) => {
        // 检查是否满足所有条件
        const matchesAllConditions = conditions.every(condition => {
          const cellValue = String(item[condition.field] || '').toLowerCase();
          const conditionValue = condition.value.toLowerCase();
          
          let result = false;
          switch (condition.operator) {
            case 'contains':
              result = cellValue.includes(conditionValue);
              break;
            case 'equals':
              result = cellValue === conditionValue;
              break;
            case 'not-equals':
              result = cellValue !== conditionValue;
              break;
            case 'starts-with':
              result = cellValue.startsWith(conditionValue);
              break;
            case 'ends-with':
              result = cellValue.endsWith(conditionValue);
              break;
            case 'greater-than':
              result = parseFloat(cellValue) > parseFloat(conditionValue);
              break;
            case 'greater-than-equals':
              result = parseFloat(cellValue) >= parseFloat(conditionValue);
              break;
            case 'less-than':
              result = parseFloat(cellValue) < parseFloat(conditionValue);
              break;
            case 'less-than-equals':
              result = parseFloat(cellValue) <= parseFloat(conditionValue);
              break;
            default:
              result = true;
          }
          
          return result;
        });
        
        return matchesAllConditions;
      });
      
      filteredDataset.source = filteredSource;
    } else if (Array.isArray(filteredDataset.source) && filteredDataset.source.length > 0) {
      // 处理二维数组格式
      const headerRow = filteredDataset.source[0];
      
      // 确保headerRow是一个数组并且有indexOf方法
      if (Array.isArray(headerRow) && typeof headerRow.indexOf === 'function') {
        const filteredSource = filteredDataset.source.filter((row, index) => {
          if (index === 0) return true; // 保留标题行
          
          // 检查是否满足所有条件
          const matchesAllConditions = conditions.every(condition => {
            const fieldIndex = headerRow.indexOf(condition.field);
            if (fieldIndex === -1) {
              return false; // 字段不存在
            }
            
            const cellValue = String(row[fieldIndex] || '').toLowerCase();
            const conditionValue = condition.value.toLowerCase();
            
            let result = false;
            switch (condition.operator) {
              case 'contains':
                result = cellValue.includes(conditionValue);
                break;
              case 'equals':
                result = cellValue === conditionValue;
                break;
              case 'not-equals':
                result = cellValue !== conditionValue;
                break;
              case 'starts-with':
                result = cellValue.startsWith(conditionValue);
                break;
              case 'ends-with':
                result = cellValue.endsWith(conditionValue);
                break;
              case 'greater-than':
                result = parseFloat(cellValue) > parseFloat(conditionValue);
                break;
              case 'greater-than-equals':
                result = parseFloat(cellValue) >= parseFloat(conditionValue);
                break;
              case 'less-than':
                result = parseFloat(cellValue) < parseFloat(conditionValue);
                break;
              case 'less-than-equals':
                result = parseFloat(cellValue) <= parseFloat(conditionValue);
                break;
              default:
                result = true;
            }
            
            return result;
          });
          
          return matchesAllConditions;
        });
        
        filteredDataset.source = filteredSource;
      } else {
        return originalDataset;
      }
    } else {
      return originalDataset;
    }
    
    return filteredDataset;
  }

  /**
   * 应用筛选条件
   */
  applyFilters(container, datasetId) {
    const conditions = this.conditions.get(datasetId) || [];
    const originalDataset = this.datasets.get(datasetId);
    
    if (!originalDataset) {
      return;
    }
    
    // 应用筛选
    const filteredDataset = this.filterDatasetWithConditions(originalDataset, conditions);
    
    // 更新实例级别的dataset对象中的筛选后数据
    this.dataset[datasetId] = filteredDataset;
    
    // 如果预览已展开，自动刷新预览数据
    const preview = container.querySelector('.dataset-preview');
    if (preview && preview.style.display === 'block') {
      this.showPreview(container, datasetId);
    }
    
    // 触发dataset筛选变化事件，通知echarts图表更新
    const event = new CustomEvent('datasetFilterChanged', {
      detail: { datasetId }
    });
    document.dispatchEvent(event);
  }

  /**
   * 导出数据集
   */
  exportDataset(datasetId) {
    const targetDataset = this.datasets.get(datasetId);
    if (!targetDataset) {
      return;
    }
    
    // 将数据集转换为JSON字符串
    const jsonString = JSON.stringify(targetDataset, null, 2);
    
    // 创建下载链接
    const blob = new Blob([jsonString], { type: 'application/json' });
    const url = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url;
    a.download = `dataset-${datasetId}.json`;
    document.body.appendChild(a);
    a.click();
    document.body.removeChild(a);
    URL.revokeObjectURL(url);
  }

  /**
   * 观察DOM变化（使用基类方法）
   */
  observeDOM(containerSelector) {
    super.observeDOM(
      containerSelector,
      'dataset-container',
      () => {
        this.renderDatasets().catch(error => {
          console.error('Dataset 渲染失败:', error)
        })
      },
      100
    )
  }

  // cleanup 使用基类默认实现
}

/**
 * dataset插件主函数
 */
export default function markdownItDataset(md) {
  // 保存默认的fence渲染器
  const defaultFenceRender = md.renderer.rules.fence || 
    function(tokens, idx, options, env, self) {
      return self.renderToken(tokens, idx, options);
    };

  // 重写fence渲染规则
  md.renderer.rules.fence = (tokens, idx, options, env, self) => {
    const token = tokens[idx];
    const code = token.content.trim();
    const info = token.info.trim();

    // 处理dataset代码块
    if (info.startsWith('dataset')) {
      try {
        // 解析新的格式: dataset datasetId: sql_query_1 datasourceId: demo_db
        let datasetId = `dataset-${idx}-${Date.now()}`;
        
        // 尝试从info中提取datasetId
        const datasetIdMatch = info.match(/datasetId:\s*(\S+)/);
        if (datasetIdMatch && datasetIdMatch[1]) {
          datasetId = datasetIdMatch[1];
        }
        
        // 检查是否是数据源查询格式（从info中检查datasourceId）
        const isDataSourceQuery = info.includes('datasourceId:');
        
        // 对于数据源查询，需要将info中的datasetId和datasourceId信息与代码内容合并
        let datasetContent = code;
        if (isDataSourceQuery) {
          // 从info中提取datasourceId信息，并与代码内容合并
          const datasourceIdMatch = info.match(/datasourceId:\s*(\S+)/);
          if (datasourceIdMatch && datasourceIdMatch[1]) {
            // 构建完整的数据集内容：第一行包含datasetId和datasourceId，后续是SQL语句
            datasetContent = `datasetId: ${datasetIdMatch ? datasetIdMatch[1] : datasetId} datasourceId: ${datasourceIdMatch[1]}\n${code}`;
          }
        }
        
        // 创建dataset容器HTML
        // 使用HTML实体编码来正确传递内容
        const encodedDataset = datasetContent.replace(/'/g, '&#39;').replace(/"/g, '&quot;');
        
        // 保存完整的原始代码用于错误报告（包含 info 行）
        const fullOriginalCode = `\`\`\`${info}\n${code}\n\`\`\``;
        const encodedOriginalCode = fullOriginalCode.replace(/'/g, '&#39;').replace(/"/g, '&quot;');
        
        return `
          <div class="dataset-container" data-dataset="${encodedDataset}" data-dataset-id="${datasetId}" data-is-datasource="${isDataSourceQuery}" data-original-code="${encodedOriginalCode}">${code}</div>
        `;
      } catch (e) {
        return `<pre class="error">Invalid dataset configuration: ${e.message}</pre>`;
      }
    }

    // 对于其他类型的代码块，使用默认渲染器
    return defaultFenceRender(tokens, idx, options, env, self);
  };
}